package com.sheng.project.study.spring.demo04;

import com.sheng.project.study.spring.demo04.test1.MainConfig1;
import com.sheng.project.study.spring.demo04.test1.Service1;
import com.sheng.project.study.spring.demo04.test1.Service2;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author liusheng
 * @date 2023/07/10
 */
public class DependencyTest {

    @Test
    public void test1() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(MainConfig1.class);
        context.refresh();
    }

    @Test
    public void test2() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        // 创建一个 BeanFactoryPostProcessor：BeanFactory 后置处理器
        context.addBeanFactoryPostProcessor(beanFactory -> {
            if (beanFactory instanceof DefaultListableBeanFactory) {
                // allowRawInjectionDespiteWrapping 这个参数用来控制是否允许循环依赖的情况下，
                // 早期暴露给被人使用的bean在后期是否可以被包装，通俗点理解就是：
                // 是否允许早期给别人使用的 bean 和最终 bean 不一致的情况，这个值默认是 false，表示不允许，
                // 也就是说你暴露给别人的 bean 和你最终的 bean 需要是一直的，你给别人的是 1，你后面不能将其修改成 2
                // 将 allowRawInjectionDespiteWrapping 设置为 true
                ((DefaultListableBeanFactory) beanFactory).setAllowRawInjectionDespiteWrapping(true);
            }
        });
        context.register(MainConfig1.class);
        context.refresh();
        System.out.println("容器初始化完毕");

        // 测试拦截是否生效
        // 获取 service1
        Service1 service1 = context.getBean(Service1.class);
        // 获取 service2
        Service2 service2 = context.getBean(Service2.class);
        System.out.println("----A-----");
        service2.m1();
        System.out.println("----B-----");
        service1.m1();
        System.out.println("----C-----");
        System.out.println(service2.getService1() == service1);
    }
}
